eslint-etc

What is eslint-etc?

The eslint-etc package provides utility functions and types for working with ESLint rules, making it easier to create and manage custom ESLint rules.

What are eslint-etc's main functionalities?

getParserServices

The getParserServices function retrieves the parser services from the ESLint context, which is useful when working with TypeScript nodes in custom ESLint rules.

const { getParserServices } = require('eslint-etc');

module.exports = {
  create(context) {
    const parserServices = getParserServices(context);
    // Use parserServices to interact with TypeScript nodes
  }
};

getTypeServices

The getTypeServices function retrieves type services from the ESLint context, allowing you to get type information for nodes when creating custom ESLint rules.

const { getTypeServices } = require('eslint-etc');

module.exports = {
  create(context) {
    const typeServices = getTypeServices(context);
    // Use typeServices to get type information
  }
};

getTypeChecker

The getTypeChecker function retrieves the TypeScript type checker from the ESLint context, enabling you to perform type checking in custom ESLint rules.

const { getTypeChecker } = require('eslint-etc');

module.exports = {
  create(context) {
    const typeChecker = getTypeChecker(context);
    // Use typeChecker to perform type checking
  }
};

Other packages similar to eslint-etc

typescript-eslint

The typescript-eslint package provides a set of tools for using ESLint with TypeScript, including a parser and a set of rules. It is more comprehensive than eslint-etc, as it includes a parser and a large set of rules specifically for TypeScript.

eslint-plugin-ts

The eslint-plugin-ts package offers a collection of ESLint rules for TypeScript. While it provides a set of rules similar to eslint-etc, it does not offer the same utility functions for creating custom rules.

eslint-plugin-typescript

The eslint-plugin-typescript package provides additional TypeScript-specific rules for ESLint. It focuses more on providing rules rather than utility functions for creating custom rules, making it less flexible than eslint-etc for custom rule development.

README

eslint-etc

More utils for use with eslint.

I use these utils to implement and test my own ESLint rules. That's their primary purpose, so the documentation is ... light.

fromFixture

fromFixture allows TSLint-like fixtures to be used to test ESlint rules. Using fixtures means that you don't have to specify lines and columns. Instead, you underline the failure locations within the fixture, like this:

{
  invalid: [
    fromFixture(stripIndent`
      const name = "alice";
            ~~~~            [foo { "identifier": "name" }]
                   ~~~~~~~  [bar]
      const role = 'cto';
            ~~~~            [foo { "identifier": "role" }]
    `),
    fromFixture(stripIndent`
      const name = "alice";
            ~~~~            [foo { "identifier": "name" }]
      const role = 'cto';
            ~~~~            [foo { "identifier": "role" }]
    `, {
      options: [{ bar: false }]
    }),
  ]
}

which is equivalent to the following:

{
  invalid: [{
    code: `const name = "alice";
const role = 'cto';`,
    errors: [{
      column: 7,
      endColumn: 11,
      line: 1,
      endLine: 1,
      messageId: "foo",
      data: {
        identifier: "name",
      },
    }, {
      column: 14,
      endColumn: 21,
      line: 1,
      endLine: 1,
      messageId: "bar",
      data: {},
    }, {
      column: 7,
      endColumn: 11,
      line: 2,
      endLine: 2,
      messageId: "foo",
      data: {
        identifier: "role",
      },
    }]
  }, {
    code: `const name = "alice";
const role = 'cto';`,
    errors: [{
      column: 7,
      endColumn: 11,
      line: 1,
      endLine: 1,
      messageId: "foo",
      data: {
        identifier: "name",
      },
    }, {
      column: 7,
      endColumn: 11,
      line: 2,
      endLine: 2,
      messageId: "foo",
      data: {
        identifier: "role",
      },
    }],
    options: [{
      bar: false
    }]
  }]
}

Specifying data in the fixture is optional. If it's omitted, data defaults to {}.

The second, optional, argument passed to fromFixture can be used to pass additional test case properties - options and output, etc.